namespace wxb
{
    template<class T>
    class vector
    {
    public:

        //原生指针类型
        typedef T* iterator;//普通类型
        typedef const T* const_iterator;//const类型
        iterator begin()
        {return _start;}
        iterator end()
        {return _finish;}
        const_iterator cbegin()
        {return  _start;}
        const_iterator cend()
        {return _finish;}


        //构造函数
        vector()//默认构造
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endOfStorage(nullptr)
        {

        }


        vector(int N,const T&value=T())
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endOfStorage(nullptr)
        {
            int i=N;
            while(i--)
            {
                push_back(value);
            }
        }

        template<class InputIterator>
        vector(InputIterator first, InputIterator last)//迭代器区间初始化，现代写法需要他
        :_start(nullptr)
        ,_finish(nullptr)
        ,_endOfStorage(nullptr)
        {
            assert(first&&last);

            _start =new T[last-first];
            _endOfStorage=_finish=_start+(last-first);
            int i=0;
            while(first!=last)
            {
                   _start[i++]=*first++;
            }
        }

        vector(const vector<T>& v)//用另一个vector初始化
         :_start(nullptr)
         ,_finish(nullptr)
         ,_endOfStorage(nullptr)
        {
            _start=new T[v.size()];
            _finish=_endOfStorage=_start+v.size();

            auto tmp=v._start;
            for(int i=0;i<v.size();i++)
            {
                _start[i]=tmp[i];
            }
        }
        vector<T>& operator= (vector<T> v)//赋值重载
        {
            ::swap(_start,v._start);
            ::swap(_finish,v._finish);
            ::swap(_endOfStorage,v._endOfStorage);

              return *this;
        }

        ~vector()//析构
        {
            delete []_start;
            _start=_finish=_endOfStorage= nullptr;
        }



         void swap(vector<T>&value)//交换空间
         {
            ::swap(_start,value._start);
             ::swap(_finish,value._finish);
             ::swap(_endOfStorage,value._endOfStorage);
         }

          void construct(const int n)//开空间
          {
               int several=size();
               T*tmp=new T[n];
               memcpy(tmp,_start,several*sizeof(T));
               _start=tmp;
               _finish=_start+several;
               _endOfStorage=_start+n;
          }


          //access
          T& operator[](size_t pos)
          {
            assert(pos<size()||pos>0);//assert里面的判断条件为正确条件，不满足就报错，守门员
           return _start[pos];
           // return *(_start+pos);
          }
        const T& operator[](size_t pos)const
        {
            assert(pos<size()||pos>0);
              return _start[pos];
            //return *_start+pos;
        }


          //capacity
            size_t size()const//元素个数
            {
                return  _finish- _start;
            }
            size_t capacity()const//总容量
            {
                return _endOfStorage-_start;
            }

            void reserve(size_t n)//对capacity操作，大扩容，小啥也不干
            {
               if(n>capacity())
               {
                   construct(n);
               }

            }
            void resize(size_t n,const T&value=T())//对size进行操作，大开空间补T，小删到当前位置
            {
                if(n>capacity())//如果大于当前容量就开空间
                {
                    construct(n);
                }
                while(_finish!=_endOfStorage)
                {
                    *_finish++=value;
                }
            }



            //modify
           void push_back(const T& n)//尾插
           {
//              if(size()==capacity())//扩容
//              {
//                  int capacityN=capacity()==0?4:capacityN*2;
//                     construct(capacityN);
//              }
//              *_finish=n;
//              _finish++;
                insert(end(),n);
           }

           void pop_back()//尾删
           {
//            if(_finish!=_start)
//            {
//                _finish--;
//            }
              erase(end());
           }
        iterator insert(iterator pos, const T& x)//在pos位置插入
        {
            size_t  length=pos-_start;
            if(capacity()<size()+1)
            {
                int capacityN=capacity()==0?4:capacityN*2;
                construct(capacityN);
            }
            pos=_start+length;

            auto tail=_finish-1;
            while(tail>=pos)
            {
                ::swap(*(tail+1),*tail--);
            }
           *pos=x;
            _finish++;
            return pos;
        }
        iterator erase(iterator pos)//删除pos位置的值
        {
            assert(pos>=_start&&pos<=_finish);//左闭右开,，为了附用右闭

             vector<int> ::iterator index=pos;
             while(index!=_finish-1)
             {
                   ::swap(*index,*(index+1));
                   index++;
             }
             _finish--;

            return pos;
        }


    private:
        iterator _start;//开始位置
        iterator _finish;//有效数据的末尾
        iterator _endOfStorage;//容量
    };

